@ *****************************************************************

@ 汇编中的符号
	@ 1.指令：	能够编译生成一条32位的机器码，且能被CPU识别和执行
	@ 2.伪指令：本身不是指令，编译器可以将其替换成若干条等效指令
	@ 3.伪操作：不会生成代码，只是在编译之前告诉编译器怎么编译
	
@ ARM指令
	@ 1.数据处理指令：		数学运算、逻辑运算
	@ 2.跳转指令：			实现程序的跳转，本质就是修改了PC寄存器
	@ 3.Load/Srore指令：	访问（读写）内存
	@ 4.状态寄存器传送指令：访问（读写）CPSR寄存器
	@ 5.软中断指令：		触发软中断异常
	@ 6.协处理器指令：		操控协处理器的指令

@ *****************************************************************

.text				@表示当前段为代码段
.global _start		@声明_start为全局符号
_start:				@汇编程序的入口

@ 1.指令:能够编译生成一条32位的机器码，且能被CPU识别和执行

	@ 1.1 数据处理指令:数学运算、逻辑运算
	
		@ 数据搬移指令
		
		@ MOV R1, #1
		@ R1 = 1
		@ MOV R2, R1
		@ R2 = R1
		
		@ MVN R0, #0xFF 
		@ R0 = ~0xFF
		
		@ 立即数
		@ 立即数的本质就是包含在指令当中的数，属于指令的一部分
		@ 立即数的优点:取指的时候就可以将其读取到CPU，不用单独去内存读取，速度快
		@ 立即数的缺点:不能是任意的32位的数字，有局限性
		@ MOV R0, #0x12345678
		@ MOV R0, #0x12
		
		@ 编译器替换
		@ MOV R0, #0xFFFFFFFF
		
		@ 数据运算指令基本格式
		@	《操作码》《目标寄存器》《第一操作寄存器》《第二操作数》
		@		操作码			指示执行哪种运算
		@		目标寄存器：	存储运算结果
		@		第一操作寄存器：第一个参与运算的数据（只能是寄存器）
		@		第二操作数：	第二个参与运算的数据（可以是寄存器或立即数）
		
		@ 加法指令
		@ MOV R2, #5
		@ MOV R3, #3
		@ ADD R1, R2, R3
		@ R1 = R2 + R3
		@ ADD R1, R2, #5
		@ R1 = R2 + 5
		
		@ 减法指令
		@ SUB R1, R2, R3
		@ R1 = R2 - R3
		@ SUB R1, R2, #3
		@ R1 = R2 - 3
		
		@ 逆向减法指令
		@ RSB R1, R2, #3
		@ R1 = 3 - R2
		
		@ 乘法指令
		@ MUL R1, R2, R3
		@ R1 = R2 * R3
		@ 乘法指令只能是两个寄存器相乘
		
		@ 按位与指令
		@ AND R1, R2, R3
		@ R1 = R2 & R3
		
		@ 按位或指令
		@ ORR R1, R2, R3
		@ R1 = R2 | R3
		
		@ 按位异或指令
		@ EOR R1, R2, R3
		@ R1 = R2 ^ R3
		
		@ 左移指令
		@ LSL R1, R2, R3
		@ R1 = (R2 << R3)
		
		@ 右移指令
		@ LSR R1, R2, R3
		@ R1 = (R2 >> R3)
		
		@ 位清零指令
		@ MOV R2, #0xFF
		@ BIC R1, R2, #0x0F
		@ 第二操作数中的哪一位为1，就将第一操作寄存器的中哪一位清零，然后将结果写入目标寄存器
		
		@ 格式扩展
		@ MOV R2, #3
		@ MOV R1, R2, LSL #1
		@ R1 = (R2 << 1)
		
		@ 数据运算指令对条件位（N、Z、C、V）的影响
		@ 默认情况下数据运算不会对条件位产生影响，在指令后加后缀”S“才可以影响
		
		@ 带进位的加法指令
		@ 两个64位的数据做加法运算
		@ 第一个数的低32位放在R1
		@ 第一个数的高32位放在R2
		@ 第二个数的低32位放在R3
		@ 第二个数的高32位放在R4
		@ 运算结果的低32位放在R5
		@ 运算结果的高32位放在R6
		
		@ 第一个数
		@ 0x00000001 FFFFFFFF
		@ 第二个数
		@ 0x00000002 00000005
		
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0x00000001
		@ MOV R3, #0x00000005
		@ MOV R4, #0x00000002
		@ ADDS R5, R1, R3
		@ ADC  R6, R2, R4
		@ 本质：R6 = R2 + R4 + 'C'
		
		@ 数据处理指令的章节练习题：两个128位数相加
		@ 第一个128位数 0x00000001 FFFFFFFF FFFFFFFF FFFFFFFF
		@ 第二个128位数 0x00000005 00000006 00000007 00000008
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0xFFFFFFFF
		@ MOV R3, #0xFFFFFFFF
		@ MOV R4, #0x00000001
	
		@ MOV R5, #0x00000008
		@ MOV R6, #0x00000007
		@ MOV R7, #0x00000006
		@ MOV R8, #0x00000005
	
		@ ADDS R9,  R1, R5
		@ ADCS  R10, R2, R6
		@ ADCS R11, R3, R7
		@ ADCS  R12, R4, R8
		
		@ 带借位的减法指令
		
		@ 第一个数
		@ 0x00000002 00000001
		@ 第二个数
		@ 0x00000001 00000005
		
		@ MOV R1, #0x00000001
		@ MOV R2, #0x00000002
		@ MOV R3, #0x00000005
		@ MOV R4, #0x00000001
		@ SUBS R5, R1, R3
		@ SBC  R6, R2, R4
		@ 本质：R6 = R2 - R4 - '!C'


	@ 1.2 跳转指令:实现程序的跳转，本质就是修改了PC寄存器
	
		@ 方式一:直接修改PC寄存器的值（不建议使用，需要自己计算目标指令的绝对地址）
@ MAIN:
		@ MOV R1, #1
		@ MOV R2, #2
		@ MOV R3, #3
		@ MOV PC, #0x18
		@ MOV R4, #4
		@ MOV R5, #5	
@ FUNC:
		@ MOV R6, #6
		@ MOV R7, #7
		@ MOV R8, #8
	
		@ 方式二:不带返回的跳转指令，本质就是将PC寄存器的值修改成跳转标号下指令的地址
@ MAIN:
		@ MOV R1, #1
		@ MOV R2, #2
		@ MOV R3, #3
		@ B   FUNC
		@ MOV R4, #4
		@ MOV R5, #5	
@ FUNC:
		@ MOV R6, #6
		@ MOV R7, #7
		@ MOV R8, #8
		
		@ 方式三:带返回的跳转指令，本质就是将PC寄存器的值修改成跳转标号下指令的地址，同时将跳转指令下一条指令的地址存储到LR寄存器
@ MAIN:
		@ MOV R1, #1
		@ MOV R2, #2
		@ MOV R3, #3
		@ BL  FUNC
		@ MOV R4, #4
		@ MOV R5, #5	
@ FUNC:
		@ MOV R6, #6
		@ MOV R7, #7
		@ MOV R8, #8
		@ MOV PC, LR
		@ 程序返回
		@ B指令与BX指令的区别：除了跳到目的地址外，还根据最低位切换处理器状态（ARM指令还是THUMB指令）
		
		@ ARM指令的条件码
		
		@ 比较指令
		@ CMP指令的本质就是一条减法指令（SUBS），只是没有将运算结果存入目标寄存器
		@ MOV R1, #1
		@ MOV R2, #2
		@ CMP R1, R2
		@ BEQ FUNC	
		@ 执行逻辑：if(EQ){B FUNC}	本质：if(Z==1){B FUNC}
		@ BNE FUNC	
		@ 执行逻辑：if(NQ){B FUNC}	本质：if(Z==0){B FUNC}
		@ MOV R3, #3
		@ MOV R4, #4
		@ MOV R5, #5
@ FUNC:
		@ MOV R6, #6
		@ MOV R7, #7

		@ ARM指令集中大多数指令都可以带条件码后缀
		@ MOV R1, #1
		@ MOV R2, #2
		@ CMP R1, R2
		@ MOVGT R3, #3
		
		@ 练习：用汇编语言实现以下逻辑
			@ int R1 = 9;
			@ int R2 = 15;
		@ START:
			@ if(R1 == R2)
			@ {
			@ 	STOP();
			@ }
			@ else if(R1 > R2)
			@ {			
			@ 	R1 = R1 - R2;
			@ 	goto START;
			@ }
			@ else
			@ {
			@ 	R2 = R2 - R1;
			@	goto START;
			@ }
		
		@ 练习答案
		@ MOV R1, #9
		@ MOV R2, #15
@ START:
		@ CMP R1,R2
		@ BEQ STOP
		@ 下面的GT与LT用的都是CMP R1,R2指令的结果
		@ SUBGT R1, R1, R2
		@ SUBLT R2, R2, R1
		@ B START
@ STOP:				
		@ B STOP
			
	@ 1.3 Load/Srore指令:访问（读写）内存
	
		@ 写内存
		@ MOV R1, #0xFF000000
		@ MOV R2, #0x40000000
		@ STR R1, [R2] 
		@ 将R1寄存器中的数据写入到R2指向的内存空间
		
		@ 读内存
		@ LDR R3, [R2]
		@ 将R2指向的内存空间中的数据读取到R3寄存器
		
		@ 读/写指定的数据类型
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0x40000000
		@ STRB R1, [R2]
		@ 将R1寄存器中的数据的Bit[7:0]写入到R2指向的内存空间
		@ STRH R1, [R2] 	
		@ 将R1寄存器中的数据的Bit[15:0]写入到R2指向的内存空间
		@ STR  R1, [R2] 	
		@ 将R1寄存器中的数据的Bit[31:0]写入到R2指向的内存空间
		
		@ LDR指令同样支持以上后缀
		
		@ 寻址方式就是CPU去寻找操作数的方式
		
		@ 立即寻址
		@ MOV R1, #1
		@ ADD R1, R2, #1
		
		@ 寄存器寻址
		@ ADD R1, R2, R3
		
		@ 寄存器移位寻址
		@ MOV R1, R2, LSL #1
		
		@ 寄存器间接寻址
		@ STR R1, [R2] 
		
		@ ...
		
		@ 基址加变址寻址
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0x40000000
		@ MOV R3, #4
		@ STR R1, [R2,R3]
		@ 将R1寄存器中的数据写入到R2+R3指向的内存空间
		@ STR R1, [R2,R3,LSL #1]
		@ 将R1寄存器中的数据写入到R2+(R3<<1)指向的内存空间
		
		@ 基址加变址寻址的索引方式
		
		@ 前索引
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0x40000000
		@ STR R1, [R2,#8]
		@ 将R1寄存器中的数据写入到R2+8指向的内存空间
		
		@ 后索引
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0x40000000
		@ STR R1, [R2],#8
		@ 将R1寄存器中的数据写入到R2指向的内存空间，然后R2自增8
		
		@ 自动索引
		@ MOV R1, #0xFFFFFFFF
		@ MOV R2, #0x40000000
		@ STR R1, [R2,#8]!
		@ 将R1寄存器中的数据写入到R2+8指向的内存空间，然后R2自增8
		
		@ 以上寻址方式和索引方式同样适用于LDR
		
		@ 跳转与存储器访问指令的章节练习题：使用汇编语言实现100以内的正整数之和
		@ MOV R1, #100
		@ MOV R2, #0
		@ B SUM
@ SUM:
		@ ADD R2, R2, R1
		@ SUB R1, R1, #1
		@ CMP R1, #0
		@ BNE SUM
		
		
		
		
		@ 多寄存器内存访问指令
		@ MOV R1, #1
		@ MOV R2, #2
		@ MOV R3, #3
		@ MOV R4, #4
		@ MOV R11,#0x40000020
		@ STM R11,{R1-R4}
		@ 将R1-R4寄存器中的数据写入到以R11为起始地址的内存空间中
		@ LDM R11,{R6-R9}
		@ 将以R11为起始地址的内存空间中的数据读取到R6-R9寄存器中
		
		@ 当寄存器编号不连续时，使用逗号分隔
		@ STM R11,{R1,R2,R4}
		@ 不管寄存器列表中的顺序如何，存取时永远是低地址对应小编号的寄存器
		@ STM R11,{R3,R1,R4,R2}
		@ 自动索引照样适用于多寄存器内存访问指令
		@ STM R11!,{R1-R4}
		
		@ 多寄存器内存访问指令的寻址方式
		@ MOV R1, #1
		@ MOV R2, #2
		@ MOV R3, #3
		@ MOV R4, #4
		@ MOV R11,#0x40000020
		@ STMIA R11!,{R1-R4}
		@ 先存储数据，后增长地址
		@ STMIB R11!,{R1-R4}
		@ 先增长地址，后存储数据
		@ STMDA R11!,{R1-R4}
		@ 先存储数据，后递减地址
		@ STMDB R11!,{R1-R4}
		@ 先递减地址，后存储数据
		
		@ 栈的种类与使用
		@ MOV R1, #1
		@ MOV R2, #2
		@ MOV R3, #3
		@ MOV R4, #4
		@ MOV R11,#0x40000020
		@ STMDB R11!,{R1-R4}
		@ LDMIA R11!,{R6-R9}
		@ 跟下面效果等同
		@ STMFD R11!,{R1-R4}
		@ LDMFD R11!,{R6-R9}
		@ 编译之后 其实就是上面的STMDB LDMIA。（反汇编可以看到）
		
		@ 栈的应用举例
		
		@ 1.叶子函数的调用过程举例
		
		@ 初始化栈指针
		@ MOV SP, #0x40000020
@ MIAN:
		@ MOV R1, #3
		@ MOV R2, #5
		@ BL  FUNC
		@ ADD R3, R1, R2
		@ B STOP
		
@ FUNC:
		@ 压栈保护现场
		@ STMFD SP!, {R1,R2}
		@ MOV R1, #10
		@ MOV R2, #20
		@ SUB R3, R2, R1
		@ 出栈恢复现场
		@ LDMFD SP!, {R1,R2}
		@ MOV PC, LR
		
		@ 2.非叶子函数的调用过程举例

		@ MOV SP, #0x40000020
@ MIAN:
		@ MOV R1, #3
		@ MOV R2, #5
		@ BL  FUNC1
		@ ADD R3, R1, R2
		@ B STOP		
@ FUNC1:
		@ STMFD SP!, {R1,R2,LR}
		@ MOV R1, #10
		@ MOV R2, #20
		@ BL  FUNC2
		@ SUB R3, R2, R1
		@ LDMFD SP!, {R1,R2,LR}
		@ MOV PC, LR
@ FUNC2:
		@ STMFD SP!, {R1,R2}
		@ MOV R1, #7
		@ MOV R2, #8
		@ MUL R3, R1, R2
		@ LDMFD SP!, {R1,R2}
		@ MOV PC, LR
		
		@ 执行叶子函数时不需要对LR压栈保护，执行非叶子函数时需要对LR压栈保护
		
	@ 1.4 状态寄存器传送指令:访问（读写）CPSR寄存器
	
		@ 读CPSR
		@ MRS R1, CPSR
		@ R1 = CPSR
		
		@ 写CPSR
		@ MSR CPSR, #0x10
		@ CPSR = 0x10
		
		@ 在USER模式下不能随意修改CPSR，因为USER模式属于非特权模式
		@ 0xD3是SVC模式，上电后CPSR的初始值就是0xD3.
		@ 若在USER模式下，再切换成0xD3 此时不会生效。因为USER模式属于非特权模式
		@ MSR CPSR, #0xD3
		
	@ 1.5 软中断指令:触发软中断
	@ 在C语言中没有对应的语句，因为软中断是ARM处理器特有的。
	@ 以系统调用write为例，linux内核借助SWI指令实现用户模式到SVC模式切换，获得更高权限后执行硬盘读写或网卡读写�
	@ 之后再借助MSR,实现从SVC模式切回到USER模式
	
		@ 异常向量表
		@ B MAIN
		@ B .
		@ B SWI_HANDLER
		@ B .
		@ B .
		@ B .
		@ B .
		@ B .
		
		@ 应用程序
@ MAIN:
		@ MOV SP, #0x40000020
		@ 初始化SVC模式下的栈指针
		@ MSR CPSR, #0x10
		@ 切换成USER模式，开启FIQ、IRQ
		@ MOV R1, #1
		@ MOV R2, #2
		@ SWI #1
		@ #1的含义：区分不同的系统调用。以write为例，#1就可以表示往磁盘写，#2就可以表示往网卡写
		@ 触发软中断异常
		@ ADD R3, R2, R1
		@ B STOP
		
		@ 异常处理程序
@ SWI_HANDLER:
		@ STMFD SP!,{R1,R2,LR}
		@ 压栈保护现场
		@ MOV R1, #10
		@ MOV R2, #20
		@ SUB R3, R2, R1
		@ LDMFD SP!,{R1,R2,PC}^
		@ 出栈恢复现场
		@ 将压入到栈中的LR（返回地址）出栈给PC，实现程序的返回
		@ ‘^’表示出栈的同时将SPSR的值传递给CPSR，实现CPU状态的恢复
		
		
	@ 1.6 协处理器指令:操控协处理器的指令
	
		@ 1.协处理器数据运算指令
		@	CDP
		@ 2.协处理器存储器访问指令
		@	STC	将协处理器中的数据写入到存储器
		@	LDC	将存储器中的数据读取到协处理器
		@ 3.协处理器寄存器传送指令  
		@	MRC	将协处理器中寄存器中的数据传送到ARM处理器中的寄存器
		@	MCR	将ARM处理器中寄存器中的数据传送到协处理器中的寄存器

@ *****************************************************************

@ 2.伪指令:本身不是指令，编译器可以将其替换成若干条等效指令

		@ 空指令 浪费CPU一段时间，实现在特定周期中不执行实际操作
		@ 观察如下两条指令，发现NOP指令的机器码和MOV R0,R0一致，所以NOP伪指令对应MOV R0,R0指令
		@ NOP
		@ MOV R0,R0
		
		@ 指令
		@ LDR 既可作为指令 也可作为伪指令
		@ LDR R1, [R2]
		@ 将R2指向的内存空间中的数据读取到R1寄存器
		
		@ 伪指令
		@ LDR R1, =0x12345678
		@ R1 = 0x12345678	
		@ LDR伪指令可以将任意一个32位的数据放到一个寄存器。背后的原理是将32位数放到了该地址后8个字节的位置上，LDR R1,[PC]
		@ 在Keil调试汇编时，PC值没有按照流水线规律显示（多8字节），主要是因为调试器对PC值进行了调整，使其指向当前执行的指令，而不是流水线中的预取地址。
		@ 这是为了方便开发者直观地理解程序执行位置，而不是严格反映硬件流水线的行为。
		
		@ LDR R1, =STOP
		@ 将STOP表示的地址写入R1寄存器
		
		@ LDR R1, STOP
		@ 将STOP地址中的内容写入R1寄存器
		
		@ 专用指令章节练习：通过状态寄存器指令，将ARM处理器的模式修改成USER模式并将FIQ与IRQ使能
		@ MSR CPSR, #0x10

@ *****************************************************************

@ 3.伪操作:不会生成代码，只是在编译之前告诉编译器怎么编译
		
		@ GNU的伪操作一般都以‘.’开头
		
		@ .global symbol
		@ 将symbol声明成全局符号
		
		@ .local symbol
		@ 将symbol声明成局部符号
		
		@ .equ DATA, 0xFF
		@ MOV R1, #DATA
		@ 类似于C语言中的宏定义，该行不生成代码不占用空间
		
		@ .macro FUNC
		@	MOV R1, #1
		@	MOV R2, #2
		@ .endm
		@ FUNC
		@ 类似于C语言中的函数
		
		@ .if 1
		@	MOV R1, #1
		@	MOV R2, #2
		@ .endif
		@ 类似C语言中的条件编译

		@.rept 3
		@ 	MOV R1, #1
		@ 	MOV R2, #2
		@.endr
		@ 将包含的代码执行3次
		
		@ .weak symbol
		@ 弱化一个符号，即告诉编译器即便没有这个符号也不要报错
		@ .weak func
		@ B func
		
		@ .word VALUE
		@ 在当前地址申请一个字的空间并将其初始化为VALUE
		@ MOV R1, #1
		@ .word 0xFFFFFFFF
		@ MOV R2, #2
		
		@ .byte VALUE	
		@ 在当前地址申请一个字节的空间并将其初始化为VALUE
		@ MOV R1, #1
		@ .byte 0xFF
		
		@ .align N
		@ 告诉编译器后续的代码2的N次方对齐
		@ .align 4
		@ MOV R2, #2
		
		@ .arm
		@ 告诉编译器后续的代码是ARM指令
		
		@ .thumb
		@ 告诉编译器后续的代码是Thumb指令
		
		@ .text				
		@ 定义一个代码段
		
		@ .data				
		@ 定义一个数据段
		
		@ .space N, VALUE
		@ 在当前地址申请N个字节的空间并将其初始化为VALUE
		@ MOV R1, #1
		@ .space 12, 0x12
		@ MOV R2, #2
		
		@ 不同的编译器伪操作的语法不同
		@ 指令与伪指令的语法由处理器ARM决定，伪操作是告诉编译器如何编译，那这跟处理器没有关系，跟编译器有关
		@ 当前使用的都是GNU的GCC编译器，此时讲解的也是GCC的语法，若切换成其他编译器，那语法就不一样了
	
@ *****************************************************************

@ C和汇编的混合编程

	@ C和汇编的混合编程原则：在哪种语言环境下符合哪种语言的语法规则
		@ 1. 在汇编中将C中的函数当做标号处理
		@ 2. 在C中将汇编中的标号当做函数处理
		@ 3. 在C中内联的汇编当做C的语句来处理

		@ 1. 方式一：汇编语言调用（跳转）C语言
			@ MOV SP, #0x40000020 
			@ MOV R1, #1
			@ MOV R2, #2
			@ BL  func_c
			@ MOV R3, #3
		
		@ 2. 方式二：C语言调用（跳转）汇编语言
@ .global FUNC_ASM
@ FUNC_ASM:
			@ MOV R4, #4
			@ MOV R5, #5
			
		@ 3. C内联（内嵌）汇编

@ *****************************************************************

@ ATPCS协议(ARM-THUMB Procedure Call Standard) ARM-Thumb 过程调用标准

	@ ATPCS协议主要内容 
		@ 意义：混合编程 在C库、C语言代码、汇编代码 确保使用相同的规则，可以相互调用
		@ 例如 我们自己写的汇编代码是满减栈，但C语言经编译后的汇编代码是空增栈，不一致就会报错。
		@ 再比方 两端C语言代码 使用的编译器不一样，如果使用规则不同，那也不兼容
	
		@ 1.栈的种类
		@ 	1.1 使用满减栈
	
		@ 2.寄存器的使用
		@	2.1 R15用作程序计数器，不能作其他用途	
		@ 	2.2 R14用作链接寄存器，不能作其他用途
		@	2.3 R13用作栈指针，不能作其他用途
		@	2.4 当函数的参数不多于4个时使用R0-R3传递，当函数的参数多于4个时，多出的部分用栈传递
		@	2.5	函数的返回值使用R0传递
		@ 	2.6 其它寄存器主要用于存储局部变量
	
.global STOP	
@ STOP:	
		@ B STOP		@死循环，防止程序跑飞	

.end				@汇编程序的结束